package com.example.video.controller;

import com.example.video.common.Result;
import com.example.video.entity.User;
import com.example.video.service.IUserService;
import com.example.video.util.RoleUtils;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.*;
import org.springframework.stereotype.Controller;

import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * @desc 用户表(User)表控制层
 * @author qiusuyang
 * @since 2024-04-13
 */
@Slf4j
@Controller
@RequestMapping("/user")
public class UserController {
    @Resource
    private IUserService userService;

    @PostMapping("/modify")
    @ResponseBody
    public Result<String> modify(@RequestParam User user){
        log.info("UserCTRL -> modify ->msg: user = "+user);
        return null;
    }

    @PostMapping("/get/item")
    @ResponseBody
    public Result<User> getItem(@RequestParam Integer id){
        Result<User> rs = new Result<>();
        log.info("UserCTRL -> modify ->msg: id = "+id);
        User user = userService.getById(id);
        log.info("UserCTRL -> modify ->msg: user = "+user);
        if(user!=null){
            rs.setData(user);
            rs.setCode(0);
            rs.setMsg("获取成功");
        }else{
            rs.setCode(-1);
            rs.setMsg("获取失败");
            rs.setData(null);
        }
        return rs;
    }

    /**
     * 通过POST请求更新用户信息。
     *
     * @param user 包含待更新用户信息的请求体。
     * @return 返回一个Result对象，其中包含更新操作的结果信息。
     * @author ayan
     */
    @PostMapping("/update")
    @ResponseBody
    public Result<String> update(@RequestBody User user){
        // 初始化结果对象
        Result<String> rs = new Result<>();
        // 打印更新的用户信息
        log.info("UserCtrl -> /update ->msg:update_user:"+user);

        // 根据用户名查询是否存在相同名称的用户
        User existingUser = userService.getByName(user.getUserName());
        existingUser.setRole(existingUser.getRole().replace("[ROLE_", "").replace("]",""));
        existingUser.setUserName(user.getUserName());
        existingUser.setUserPwd(user.getUserPwd());
        if(user.getUserPwd() == null){
            existingUser.setUserPwd(existingUser.getUserName()+"123456");
        }

        // 检查是否存在同名但ID不同的用户，如果存在，则更新失败
//        if (existingUser != null && !existingUser.getId().equals(user.getId())) {
//            rs.setCode(-1);
//            rs.setMsg("修改用户失败！已有该用户名的用户！");
//            return rs;
//        }

        // 尝试更新用户详细信息
        log.info("UserCtrl -> /update ->msg:existsUser = "+existingUser);
        boolean updateResult = userService.updateUserDetails(existingUser);

        // 根据更新结果设置返回信息
        if (!updateResult) {
            rs.setCode(-1);
            rs.setMsg("修改用户失败！");
        } else {
            rs.setCode(0);
            rs.setMsg("修改用户成功！");
        }

        return rs;
    }
    /**
     * 接收包含用户ID的Map对象作为请求体，删除指定ID的用户。
     * 返回一个Result对象，其中包含删除操作的结果信息。
     *
     * @param data 请求体中的Map对象，应包含一个键为"userId"，值为待删除用户ID的条目。
     * @return Result<String> 对象，包含删除操作的结果状态和消息。
     * @author ayan
     */
    @PostMapping("/delete")
    @ResponseBody
    public Result<String> deleteUser(@RequestBody Map<String, Integer> data) {
        // 从请求体中获取用户ID
        Integer userId = data.get("userId");
        // 初始化结果对象
        Result<String> result = new Result<>();
        try {
            // 调用userService的deleteUserById方法尝试删除用户
            boolean deleted = userService.deleteUserById(userId);
            // 根据删除操作的结果设置结果对象的状态和消息
            if (deleted) {
                result.setCode(0);
                result.setMsg("删除成功");
            } else {
                result.setCode(-1);
                result.setMsg("删除失败");
            }
        } catch (Exception e) {
            // 捕获任何异常，设置结果对象的状态和消息为删除异常
            result.setCode(-1);
            result.setMsg("删除异常：" + e.getMessage());
        }
        // 返回结果对象
        return result;
    }

    /**
     * 管理页面搜索用户列表
     * @param page 页面
     * @param limit 大小
     * @param role 角色
     * @return 用户列表
     */
    @PostMapping("/search")
    @ResponseBody
    public Result<List<User>> search(@RequestParam Integer page, @RequestParam Integer limit, @RequestParam(defaultValue = "") String role){
        Result<List<User>> rs = new Result<>();
        List<User> list = userService.getListByRole(page, limit, role);
        log.info("UserCTRL -> search ->msg: list = "+list);
        if (list.isEmpty()) {
            rs.setCode(-1);
            rs.setData(null);
            rs.setMsg("获取失败！");
        } else {
            rs.setCode(0);
            rs.setData(list);
            rs.setMsg("获取成功！");
        }
        rs.setCount(list.size());
        return rs;
    }

//    @PostMapping("/delete")
//    @ResponseBody
//    public Result<String> delete(@RequestParam Integer userId){
//        Result<String> rs = new Result<>();
//        log.info("UserCTRL -> search ->msg: userId = "+userId);
//        if(userService.deleteByUserId(userId)){
//            rs.setMsg("删除成功！！");
//            rs.setCode(0);
//        }else{
//            rs.setMsg("删除失败！！");
//            rs.setCode(-1);
//        }
//
//
//        return rs;
//    }


    @PostMapping("/add")
    @ResponseBody
//    @PreAuthorize("hasRole('ADMIN')")
    public Result<String> add(@RequestBody User user){
        Result<String> rs = new Result<>();
        rs.setCode(-1);
        rs.setCount(0);
        rs.setCode(null);
        if(userService.getByName(user.getUserName()) == null){
//            String roleStr = user.getRole().replace("[", "").replace("]", "").replace("ROLE_", "");
//
//            user.setRole(roleStr);
            log.info("saveuser1:"+user);

            userService.saveUserDetails(user);
            if(userService.getByName(user.getUserName()) == null){
                rs.setMsg("添加用户失败！添加新分组失败！");
            }else{
                rs.setCode(0);
                rs.setMsg("添加用户成功！");
                rs.setCount(0);
                rs.setCode(null);
            }
        }else{
            rs.setMsg("添加用户失败！已有该用户名的用户！");
        }
        return rs;
    }
    /**
     * 从用户列表中获取数据。
     * 根据用户的认证状态和角色，返回不同的数据。
     * @author ayan
     * @return ResponseEntity<?> 根据用户角色返回不同的响应体。如果用户未认证，返回未授权状态；如果认证通过，根据角色返回不同的数据。
     */
    @ResponseBody
    @PostMapping("/userlist")
    public ResponseEntity<?> getData() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication != null && authentication.isAuthenticated()) {
            // 获取用户的所有权限
            Collection<? extends GrantedAuthority> authorities = authentication.getAuthorities();
            // 处理角色字段，将"[ROLE_]"前缀和"]"后缀移除，并去空格，然后收集到列表中
            List<String> roles =  RoleUtils.extractRoles(authorities);
//            log.info(roles);
            // 根据用户角色，返回对应的数据
            if (roles.contains("ROLE_ADMIN")) {
                // 如果用户是管理员，返回管理员数据
                return ResponseEntity.ok("Admin data");
            } else if (roles.contains("ROLE_USER")) {
                // 如果用户是普通用户，返回普通用户数据
                return ResponseEntity.ok("User data");
            }
        }
        // 如果用户未认证，返回未授权状态
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Unauthorized");
    }
    @ResponseBody
    @PostMapping("/userRoleList")
    public Result<List<User>> getUserRoleList() {
        Result<List<User>> result = new Result<>();
        try {
            List<User> roles = userService.getAllRoles();
            result.setCode(0);
            result.setData(roles);
            result.setMsg("获取角色列表成功");
        } catch (Exception e) {
            result.setCode(-1);
            result.setMsg("获取角色列表失败");
        }
        return result;
    }

}
